
import sys
import time
import datetime
import os
import random

import numpy as np
import pandas as pd

from scipy import stats

from bokeh.plotting import figure, output_file, save

from cycler import cycler

%matplotlib notebook
import matplotlib.pyplot as plt


def readFile(ID, GR, testMode = False):
    try:
        if testMode:
            start = time.perf_counter()
            
        path = os.path.join(os.getcwd(),'MergedData/')
        fileName = str(ID) + "-" + str(GR) + ".xlsx"
        pathToData = os.path.join(path, fileName)
        
        data = pd.read_excel(pathToData, index_col=0, sheet_name = None)
        
        if testMode:
            print(f"readFile in {time.perf_counter() - start}s for participant {ID} group {GR}")
        
        return data
    except Exception as e:
        print("error in readFile")
        print(e)


def readAllData(participantsDict, testMode = False):
    try:
        if testMode:
            start = time.perf_counter()
        
        listOfDataFrames = []
        
        for key, value in participantsDict.items():
       
            listOfDataFrames.append(readFile(key, value))
        
        if testMode:# or fullTestMode:
            print(f"\nreadAllData in {time.perf_counter() - start}s")
            
        return listOfDataFrames

    except Exception as e:
        print("error in readAllData")
        print(e)


def getIndexForPhase(experimentDataList, testMode = False):
    try:
        if testMode or fullTestMode:
            start = time.perf_counter()            
        
        breakLenghts = []
        for dataDictionary in experimentDataList:

            firstInd = True
            secInd = False
            thirdInd = False
            fourthInd = False
            fifthInd = False

            adaptationPEphase = ()
            instructionPhase = ()
            breakPhase = ()
            adaptationVEphase = ()
            
            phaseStart = 0
            phaseEnd = 0

            i = 0
            for item in dataDictionary['Experiment_Data'].itertuples():
                if firstInd and item[3] == 'adaptation PE':
                    firstInd = False
                    phaseStart = i
                    secInd = True
                elif secInd and item[3] != 'adaptation PE' and item[18] == 'Audio_1' :
                    secInd = False
                    adaptationPEphase = (phaseStart, i-1)
                    phaseStart = i
                    thirdInd = True
                elif thirdInd and item[18] != 'Audio_1': 
                    #2ms difference in break start and audioClip playing caused an error here for sample 30 
                    thirdInd = False
                    instructionPhase = (phaseStart, i-1)
                    phaseStart = i
                    fourthInd = True
                elif fourthInd and item[3] != 'break':
                    fourthInd = False
                    breakPhase = (phaseStart, i - 1)
                    phaseStart = i
                    fifthInd = True
                elif fifthInd and item[3] != 'adaptation VE':
                    adaptationVEphase = (phaseStart, i - 1)
                    break
                i += 1
            dataDictionary['phases'] = adaptationPEphase, instructionPhase, breakPhase, adaptationVEphase
            
            breakLenghts.append(breakPhase)
            
            if testMode:
                print(f"adaptationPEphase : {adaptationPEphase}")
                print(f"instructionPhase : {instructionPhase}")
                print(f"breakPhase : {breakPhase}")
                print(f"adaptationVEphase : {adaptationVEphase}")
                print('_' * 100 + '1')
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationPEphase[0]-1])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationPEphase[0]])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationPEphase[0]+1])
                print("to")
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationPEphase[1]-1])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationPEphase[1]])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationPEphase[1]+1])
                print('_' * 100+ '2')
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[instructionPhase[0]-1])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[instructionPhase[0]])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[instructionPhase[0]+1])
                print("to")
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[instructionPhase[1]-1])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[instructionPhase[1]])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[instructionPhase[1]+1])
                print('_' * 100+ '3')
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[breakPhase[0]-1])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[breakPhase[0]])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[breakPhase[0]+1])
                print("to")
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[breakPhase[1]-1])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[breakPhase[1]])
                print(dataDictionary['Experiment_Data']['Audio_clip'].iloc[breakPhase[1]+1])
                print('_' * 100+ '4')
                print(dataDictionary['Experiment_Data']['Phase'].iloc[breakPhase[0]-1])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[breakPhase[0]])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[breakPhase[0]+1])
                print('to')
                print(dataDictionary['Experiment_Data']['Phase'].iloc[breakPhase[1]-1])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[breakPhase[1]])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[breakPhase[1]+1])
                print('_' * 100+ '5')
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationVEphase[0]-1])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationVEphase[0]])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationVEphase[0]+1])
                print('to')
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationVEphase[1]-1])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationVEphase[1]])
                print(dataDictionary['Experiment_Data']['Phase'].iloc[adaptationVEphase[1]+1])
                print('_' * 100)

        if testMode:    
            print('_'*100)
            print(breakLenghts)
            print('_'*100)
        breakLenghts = [tup[1] - tup[0] for tup in breakLenghts]
        breakLenghts.sort()
        
        if testMode:
            print(breakLenghts)
            print('_'*100)
            print(breakLenghts[0])
            print('_'*100)
            print(breakLenghts[-1])
            print('_'*100)

        converterToSeconds = lambda ms : divmod(ms,100)
        breakPhaseConverted = []

        for ms in breakLenghts:
            s = converterToSeconds(ms)
            breakPhaseConverted.append(f"{s[0]}''.{s[1]}")
        
        
        breakLenghts = [item/100 for item in breakLenghts]
        print('_'*100)
        print(f'Shortest break : {breakLenghts[0]}')
        print(f'Longest break : {breakLenghts[-1]}')
        print('_'*80)
        print(f'Mean break length : {np.mean(breakLenghts)}')
        print(f'SD break length : {np.std(breakLenghts)}')
        print('_'*40)
        print(f'Median break length : {np.median(breakLenghts)}')
        print(f'Q1 and Q3 break : {np.quantile(breakLenghts,[.25,.75])}')
        
        
        fig6, ax6 = plt.subplots(figsize=(8, 8))
        ax6.boxplot(breakLenghts, notch=True, vert = True, patch_artist = True, labels = ['Lenght of break stage'])
        ax6.yaxis.grid(True)
        ax6.set_ylabel('seconds')
        ax6.set_title('Lenght of break stage')

        ax6.set_prop_cycle(color=['red'])
        fig6.show()
        
        fig7, ax7 = plt.subplots(figsize=(8, 8))
        ax7.hist(breakLenghts,30)
        ax7.axvline(x=np.mean(breakLenghts), c = 'r')
        ax7.axvline(x=np.mean(breakLenghts) + np.std(breakLenghts), c = 'r', ls = '--')
        ax7.axvline(x=np.mean(breakLenghts) - np.std(breakLenghts), c = 'r', ls = '--')
        ax7.set_ylabel('samples')
        ax7.set_xlabel('seconds')
        ax7.set_title('Lenght of break stage')
        fig7.show()
        
        if testMode or fullTestMode:
            print(f"\ngetIndexForPhase in {time.perf_counter() - start}s")

        return experimentDataList
    except Exception as e:
        print("error in getIndexForPhase")
        print(e)


def calculateMeanAge(experimentDataList, testMode = False):
    try:
        if testMode or fullTestMode:
            start = time.perf_counter()
            
        malesAge = []
        femalesAge = []
        
        for item in experimentDataList:
            if item['Participant_Data'][0].get('Gender') == 0:
                malesAge.append(int(item['Participant_Data'][0].get('Age')))
            else:
                femalesAge.append(int(item['Participant_Data'][0].get('Age')))
        ageList = [*malesAge, *femalesAge]
        
        sampleAgeData = (np.mean(ageList), np.std(ageList), np.median(ageList), len(ageList)) 
        
        print(f"Average participant age : {sampleAgeData[0]}")
        print(f"Standard deviation of participant age : {sampleAgeData[1]}")
        print(f"Median of participant age : {sampleAgeData[2]}")
        print(f'N = {sampleAgeData[3]}')

        sampleFemaleAgeData = (np.mean(femalesAge), np.std(femalesAge), np.median(femalesAge), len(femalesAge)) 
        
        print('_'*80)
        print(f'Mean female age : {sampleFemaleAgeData[0]}')
        print(f"Standard deviation of female age : {sampleFemaleAgeData[1]}")
        print(f"Median of female age : {sampleFemaleAgeData[2]}")
        print(f'N = {sampleFemaleAgeData[3]}')

        sampleMaleAgeData = (np.mean(malesAge), np.std(malesAge), np.median(malesAge), len(malesAge)) 
        
        print(f'\nMean male age : {sampleMaleAgeData[0]}')
        print(f"Standard deviation of male age : {sampleMaleAgeData[1]}")
        print(f"Median of male age : {sampleMaleAgeData[2]}")
        print(f'N = {sampleMaleAgeData[3]}')

        l1 = [i for i in range(1, len(femalesAge)+1)]
        l2 = ['Mean','Standard Deviation', 'Median', 'N']
        l3 = ['-' for i in range(1, len(femalesAge)+1)]
        dfIndex = [*l1,* l2]
        ageDF = pd.DataFrame(columns = ['Females Age', 'Males Age', 'Average'], index = dfIndex)
        ageDF['Females age'] = [*femalesAge, *list(sampleFemaleAgeData)]
        ageDF['Males age'] = [*malesAge, *list(sampleMaleAgeData)]
        ageDF['Average age'] = [*l3, *list(sampleAgeData)]
        
        # on one plot:
        allAgeData = [femalesAge, ageList, malesAge]
        labels = ['Female age', 'Average age', 'Male age']
        colors = ['lightcoral', 'forestgreen', 'lightskyblue'] # https://matplotlib.org/stable/gallery/color/named_colors.html
        
        #plt.close()
        fig1, ax1 = plt.subplots(figsize=(8, 8))
        ax1.boxplot(allAgeData, notch=True, vert = True, patch_artist = True, labels = labels)
        ax1.yaxis.grid(True)
        ax1.set_ylabel('age')
        ax1.set_title('Participants age')
        #fig1.gca().set_color_cycle(['red', 'green', 'blue']) # deprecated
        #cy = cycler('color',  ['red', 'green', 'blue'])
        #ax1.set_prop_cycle(cy)# ['lightcoral', 'forestgreen', 'lightskyblue'])
        
        ax1.set_prop_cycle(color=['red', 'green', 'blue'])
        """
        for ax, color in zip(ax1.gca(), colors):
            ax.set_facecolor(color)
        """
        fig1.show()
        # to add violins:
        # https://matplotlib.org/stable/gallery/statistics/customized_violin.html#sphx-glr-gallery-statistics-customized-violin-py
        
        if testMode or fullTestMode:
            print(f"\ncalculateMeanAge in {time.perf_counter() - start}s")
        
        return ageDF
            
    except Exception as e:
        print('error in calculateMeanAge')
        print(e)


def testingHRQualityPerSample(experimentDataList, showGraphs = False, testMode = False):
    """
    Checking number of -1 in sample 'PPG_to_HR_CONSENSYS'
    Total and phase wise
    """
    try:
        if testMode or fullTestMode:
            start = time.perf_counter()
            
        totalNa1all = []
        totalNa2all = []
        totalNa3all = []
        totalNa4all = []
        totalNaTotalAll = []
        
        total1all = []
        total2all = []
        total3all = []
        total4all = []
        totalTotalAll = []
        
        for item in experimentDataList:
            
            totalNa1 = 0
            totalNa2 = 0
            totalNa3 = 0
            totalNa4 = 0
            totalNaAll = 0
            
            total1 = 0
            total2 = 0
            total3 = 0
            total4 = 0
            totalAll = 0
            
            if testMode:
                ID = int(item['Participant_Data'][0].get('ID'))
                if ID > 9:
                    ID = f'00{ID}'
                elif ID > 99:
                    ID = 'f0{ID}'
                elif ID > 999:
                    ID = 'f{ID}'
                else:
                    ID = f'000{ID}'
                print(ID)
                
            totalNaInSample = 0
            
            totalNaInAdaptationPEphase = 0
            totalNaInInstructionPhase = 0
            totalNaInBreakPhase = 0
            totalNaInAdaptationVEphase = 0
            
            start1 = item['phases'][0][0]
            end1 = item['phases'][0][1]
            start2 = item['phases'][1][0]
            end2 = item['phases'][1][1]
            start3 = item['phases'][2][0]
            end3 = item['phases'][2][1]
            start4 = item['phases'][3][0]
            end4 = item['phases'][3][1]
            
            i = 0
            for val in item['Experiment_Data']['PPG_to_HR_CONSENSYS']:                   
                if val == -1:
                    totalNaInSample += 1
                    if i < end1:
                        totalNaInAdaptationPEphase += 1
                    elif i < end2: #sometimes audio phase was overlaping 
                        totalNaInInstructionPhase += 1
                    elif i < end3:
                        totalNaInBreakPhase += 1
                    elif i < end4:
                        totalNaInAdaptationVEphase += 1
                i += 1
                        
            totalRows = len(item['Experiment_Data']['PPG_to_HR_CONSENSYS'])
            
            if testMode:
                print(f"\nstart1 : {start1} | end1 : {end1}")
                print(f"start2 : {start2} | end2 : {end2}")
                print(f"start3 : {start3} | end3 : {end3}")
                print(f"start4 : {start4} | end4 : {end4}")
           
            totalRowsInAdaptationPEphase = end1 - start1 +1
            totalRowsInInstructionPhase = end2 - start2 +1
            totalRowsInBreakPhase = end3 - start3 +1
            totalRowsInAdaptationVEphase = end4 - start4 +1
            
            if testMode:
                print(f"\ntotalRows : {totalRows}")
                print(f"totalRowsInAdaptationPEphase : {totalRowsInAdaptationPEphase}")
                print(f"totalRowsInInstructionPhase : {totalRowsInInstructionPhase}")
                print(f"totalRowsInBreakPhase : {totalRowsInBreakPhase}")
                print(f"totalRowsInAdaptationVEphase : {totalRowsInAdaptationVEphase}")

            toAppendInAdaptationPEphase = (totalNaInAdaptationPEphase,
                                           totalRowsInAdaptationPEphase,
                                           totalNaInAdaptationPEphase/totalRowsInAdaptationPEphase)
            
            totalNa1all.append(totalNaInAdaptationPEphase)
            total1all.append(totalRowsInAdaptationPEphase)
            
            toAppendInInstructionPhase = (totalNaInInstructionPhase,                                           
                                          totalRowsInInstructionPhase,
                                          totalNaInInstructionPhase/totalRowsInInstructionPhase)
            
            totalNa2all.append(totalNaInInstructionPhase)
            total2all.append(totalRowsInInstructionPhase)
            
            toAppendInBreakPhase = (totalNaInBreakPhase,
                                    totalRowsInBreakPhase,
                                    totalNaInBreakPhase/totalRowsInBreakPhase)
            
            totalNa3all.append(totalNaInBreakPhase)
            total3all.append(totalRowsInBreakPhase)
            
            toAppendInAdaptationVEphase = (totalNaInAdaptationVEphase,
                                           totalRowsInAdaptationVEphase,
                                           totalNaInAdaptationVEphase/totalRowsInAdaptationVEphase)
            
            totalNa4all.append(totalNaInAdaptationVEphase)
            total4all.append(totalRowsInAdaptationVEphase)
            
            if testMode:
                print(f'\ntoAppendInAdaptationPEphase : {toAppendInAdaptationPEphase}')
                print(f'toAppendInInstructionPhase : {toAppendInInstructionPhase}')
                print(f'toAppendInBreakPhase : {toAppendInBreakPhase}')
                print(f'toAppendInAdaptationVEphase : {toAppendInAdaptationVEphase}')
            
            toAppendTotal = (totalNaInSample,
                             totalRows, 
                             totalNaInSample/totalRows)
            
            totalNaTotalAll.append(totalNaInSample)
            totalTotalAll.append(totalRows)
            
            toAppend = {}
            toAppend['adaptation PE phase'] = toAppendInAdaptationPEphase
            toAppend['instruction phase'] = toAppendInInstructionPhase
            toAppend['break phase'] = toAppendInBreakPhase
            toAppend['adaptation VE phase'] = toAppendInAdaptationVEphase
            toAppend['total'] = toAppendTotal
            
            if testMode:
                print(f"\ntoAppend for participant {ID} :\n {toAppend}")
                print('_'*100)
                        
            item['Missing_HR'] = toAppend

            totalNa1 += totalNaInAdaptationPEphase
            totalNa2 += totalNaInInstructionPhase
            totalNa3 += totalNaInBreakPhase
            totalNa4 += totalNaInAdaptationVEphase
            totalNaAll += totalNaInSample
            total1 += totalRowsInAdaptationPEphase
            total2 += totalRowsInInstructionPhase
            total3 += totalRowsInBreakPhase
            total4 += totalRowsInAdaptationVEphase
            totalAll += totalRows
                
        if testMode or fullTestMode:
                        
            totalErrors = (totalNa1/total1, totalNa2/total2, totalNa3/total3, total4 ,totalNa4/total4, totalNaAll/totalAll)
            
            allResults = {}
            allResults['total adaptation PE phase'] = (totalNa1, total1, totalErrors[0])
            allResults['total instruction phase'] = (totalNa2, total2, totalErrors[1])
            allResults['total break phase'] = (totalNa3, total3, totalErrors[2])
            allResults['total adaptation VE phase'] = (totalNa4, totalErrors[3])
            allResults['total mean'] = (totalNaAll, totalAll, totalErrors[4])
            
            if testMode:
                print('='*100)
                print(allResults)
                      
            
            allPhaseErrorData = [[na / total for na, total in zip(totalNa1all, total1all)],
                                 [na / total for na, total in zip(totalNa2all, total2all)],
                                 [na / total for na, total in zip(totalNa3all, total3all)],
                                 [na / total for na, total in zip(totalNa4all, total4all)],
                                 [na / total for na, total in zip(totalNaTotalAll, totalTotalAll)]]
            
            if testMode:
                print('_'*200)
                print('allPhaseErrorData')
                print(allPhaseErrorData)
            
            if showGraphs:
                labels = ['Adaptation PE', 'Instruction', 'Break', 'Adaptation VE']
                fig4, ax4 = plt.subplots(figsize=(8, 8))
                ax4.boxplot(allPhaseErrorData[0:4], notch=True, vert = True, patch_artist = True, labels = labels)
                ax4.yaxis.grid(True)
                ax4.set_ylabel('Interpolated HR')
                ax4.set_title('Per phase error distribution')

                ax4.set_prop_cycle(color=['red', 'green', 'blue','yellow'])
                fig4.show()

                fig5, ax5 = plt.subplots(figsize=(8, 8))
                ax5.boxplot(allPhaseErrorData[4], notch=True, vert = True, patch_artist = True, labels = ['Total error'])
                ax5.yaxis.grid(True)
                ax5.set_ylabel('Interpolated HR')
                ax5.set_title('Total error distribution')

                ax5.set_prop_cycle(color=['red'])
                fig5.show()
            
            if testMode or fullTestMode:
                print(f"\ntestingHRQualityPerSample in {time.perf_counter() - start}s")
            
        return experimentDataList

    except Exception as e:
        print("error in testingHRQualityPerSample")
        print(e)


def calculateMeansPerPhase(experimentDataList, thresholds = [1], testMode = False): 
    try:
        if testMode or fullTestMode:
            start = time.perf_counter()
        
        phases = ['adaptation PE', 'instruction', 'break', 'adaptation VE']
        newNames = lambda item : f'threshold : {int((1-item) * 100)}%'
        
        columnNames1 = [newNames(item) for item in thresholds]
        columnNames3 = [f'targeted {newNames(item)}' for item in thresholds]

        d = {}
        for thresholdLevel in [*columnNames1, *columnNames3]:
            d[thresholdLevel] = pd.DataFrame(columns = phases, index = pd.RangeIndex(0, len(experimentDataList)))        
        meansHR = pd.concat(d, axis=1)
        
        columnNames2 = ['Skin Conductance', 'Phasic Component', 'Tonic Component']
        d = {}
        for parameter in columnNames2:
            d[parameter] = pd.DataFrame(columns = phases, index = pd.RangeIndex(0, len(experimentDataList)))        
        meansSC = pd.concat(d, axis=1)
        
        i = 0
        for item in experimentDataList:
            ID = int(item['Participant_Data'][0].get('ID'))
            
            error1 = item['Missing_HR'].get('adaptation PE phase')[-1]
            error2 = item['Missing_HR'].get('instruction phase')[-1]
            error3 = item['Missing_HR'].get('break phase')[-1]
            error4 = item['Missing_HR'].get('adaptation VE phase')[-1]
            
            errorsDict = dict(zip(phases, [error1, error2, error3, error4]))
            
            phaseLengths = []
            rejected = False
            j = 0
            for phase in item['phases']:
                                
                sampleMeanPhaseHR = np.mean(item['Experiment_Data']['HR_CONSENSYS_interpolated'].iloc[phase[0]:phase[1]])
                phaseLengths.append((phase[1] - phase[0])/100)
                k = 0
                for cutOff in thresholds:
                    #strict cutOff:
                    if error1 <= cutOff and error2 <= cutOff and error3 <= cutOff and error4 <= cutOff:
                        meansHR.loc[i,(columnNames1[k], phases[j])] = sampleMeanPhaseHR
                    elif testMode and not rejected:
                        rejected = True
                        print(f'{i}) At threshold : {1 - cutOff} sample {ID} was rejected from HR analysis')
                    
                    #targeted cutOff:                        
                    if errorsDict[phases[j]] <= cutOff:
                        meansHR.loc[i,(columnNames3[k], phases[j])] = sampleMeanPhaseHR
                    elif testMode:
                        print(f'{i}) At threshold : {1 - cutOff} sample {ID} was rejected from targeted HR analysis in {phases[j]}')
                    
                    k += 1 
                    
                meansSC.loc[i,(columnNames2[0], phases[j])] = np.mean(item['Experiment_Data']['Skin_Conductance'].iloc[phase[0]:phase[1]])
                meansSC.loc[i,(columnNames2[1], phases[j])] = np.mean(item['Experiment_Data']['Skin_Conductance_Phasic_CVX'].iloc[phase[0]:phase[1]])
                meansSC.loc[i,(columnNames2[2], phases[j])] = np.mean(item['Experiment_Data']['Skin_Conductance_Tonic_CVX'].iloc[phase[0]:phase[1]])                
                j += 1
            
            for l in range(len(phases)):
                meansHR.loc[i,('Phases lengths', phases[l])] = meansSC.loc[i,('Phases lengths', phases[l])] = phaseLengths[l]
            meansHR.loc[i,'Gender'] = meansSC.loc[i,'Gender'] = int(item['Participant_Data'][0].get('Gender'))
            meansHR.loc[i,'Age'] = meansSC.loc[i,'Age'] = int(item['Participant_Data'][0].get('Age'))
            meansHR.loc[i,'MSSQ'] = meansSC.loc[i,'MSSQ'] = int(item['Participant_Data'][0].get('MSSQ'))
            meansHR.loc[i,'ID'] = meansSC.loc[i,'ID'] = ID
            
            i += 1
        
        if testMode or fullTestMode:
            print('_'*100)
            print('meansHR : \n')
            display(meansHR)
            print('_'*100)
            print('\nmeansSC : \n')
            display(meansSC)
            print(f"\ncalculateMeansPerPhase in {time.perf_counter() - start}s")
        return meansHR, meansSC
        
    except Exception as e:
        print('error in calculateMeansPerPhase')
        print(e)


def statisticalTestsOnData(meansSC, meansHR, thresholds = [1], testMode = False):
    try:
        if testMode or fullTestMode:
            start = time.perf_counter()

        startHighlight0 = '\x1b[30;43m'
        startHighlight1 = '\x1b[33;42m'
        startHighlight2 = '\x1b[32;40m'
        endHifghlight = '\x1b[0m'

        phases = ['adaptation PE', 'instruction', 'break', 'adaptation VE']
        parameters = ['Skin Conductance', 'Phasic Component', 'Tonic Component']
        
        tests = []        
        phasesNo = len(phases)
        for i in range(phasesNo):
            if i == 0:
                for j in range(1, phasesNo):
                    tests.append((phases[i], phases[j]))
            elif i == phasesNo:
                break
            else:
                for j in range(i+1, phasesNo):
                    tests.append((phases[i],phases[j]))
        
        correls = ['Phases lengths','Age','MSSQ']# 'Gender' would had to be between groups as its 0 1 - further work
        
        condition = lambda cond : f'{cond[0]} - {cond[1]}'
        outerIndex = [condition(test) for test in tests]

        newName = lambda item : f'threshold : {int((1-item) * 100)}%'
        hrIndexes = [newName(threshold) for threshold in thresholds]

        innerIndex = [*parameters, *hrIndexes]

        columnNames = ['N',
                       'mean difference',
                       'standard deviation',
                       'Shapiro-Wilk statistic','Shapiro-Wilk pvalue',
                       'kurtosis statistic','kurtosis pvalue', 'skew', 
                       'Ttest statistic', 'Ttest pvalue',
                       'Wilcoxon statistic', 'Wilcoxon pvalue']

        d = {}
        for outerInd in outerIndex:
            d[outerInd] = pd.DataFrame(columns = columnNames, index = hrIndexes)       
        resultsDF = pd.concat(d, axis=0)


        for test in tests:
            outerI = condition(test)

            for parameter in parameters:        
                df = pd.DataFrame({test[0] : meansSC.loc[:,(parameter, test[0])],
                                  test[1] : meansSC.loc[:,(parameter, test[1])]})
                df['delta'] = df[test[0]] - df[test[1]]
                 
                if testMode:
                    print('*-'*50)
                    print('df in statisticalTestsOnData :')
                    display(df)
                    print('-*'*40)
                    print('meansSC')
                    display(meansSC)
                    print('-*'*40)
                    print('meansHR')
                    display(meansHR)
                    print('*-'*50)
                
                meanVal = np.mean(df['delta'])
                stdVal = np.std(df['delta'])
                shapiro = stats.shapiro(df['delta'])
                kurtosis = stats.kurtosistest(df['delta'])
                skew = stats.skew(df["delta"])
                if testMode or fullTestMode:
                    print('\n' * 3 + startHighlight0 + f'_ ' * 12 
                          + f'Test of {parameter} for : {test[0]} - {test[1]}'
                          + f' _' * 12 + endHifghlight)
                    print('_' * 100)
                    if testMode:
                        display(df)
                        display(df.dropna())
                        
                    print('_' * 80 + '\n')
                    print(f'mean for differences in {parameter} for {test[0]} - {test[1]} : {meanVal}')
                    print(f'standard deviation for differences in {parameter} for {test[0]} - {test[1]} : {stdVal}')
                    print('_' * 80)
                    print('Shapiro-Wilk :')
                    print(shapiro)
                    print('_'*50)
                    print('kurtosistest :')
                    print(kurtosis)
                    print('_'*50)
                    print(f'Skew : {skew}')
                    print('_'*50)
                
                fig2, ax2 = plt.subplots(figsize=(8, 8))
                ax2.hist(df['delta'],20)
                ax2.axvline(x=meanVal, c = 'r',
                            label = f'Mean {parameter} for {test[0]} - {test[1]} : {meanVal}')
                ax2.axvline(x=meanVal + stdVal, c = 'r', ls = '--', 
                            label = f'+SD : {meanVal + stdVal}')
                ax2.axvline(x=meanVal - stdVal, c = 'r', ls = '--', 
                            label = f'-SD : {meanVal - stdVal}')
                ax2.legend()
                fig2.show()
                
                tTest = stats.ttest_rel(df[test[0]], df[test[1]])
                wilcoxon = stats.wilcoxon(df[test[0]], df[test[1]])

                print(startHighlight1 + '~' * 100 + endHifghlight)
                print(startHighlight2 + f'>>> test results of {parameter} for {test[0]} - {test[1]} : ' + endHifghlight)
                print(f'\nTtest results : {tTest}')
                print('.'*100)
                print(f'Wilcoxon signed-rank test results : {wilcoxon}\n')
                print(startHighlight1 + '~' * 100 + endHifghlight)

                results = [len(df[test[0]].dropna()),
                                  meanVal, stdVal,
                                  shapiro[0], shapiro[1], 
                                  kurtosis[0], kurtosis[1], skew,
                                  tTest[0], tTest[1],
                                  wilcoxon[0], wilcoxon[1]]

                i = 0
                for colName in columnNames:
                    resultsDF.loc[(outerI, parameter), colName] = results[i]
                    i += 1
                
                #added for correlations: # 'Gender' would had to be between groups as its 0 1
                for param in correls:
                    if param == 'Phases lengths':                        
                        df[param] = meansSC.loc[:,(param, 'break')]
                        title = 'Break length[s]'
                    else:
                        df[param] = meansSC.loc[:, param]
                        title = param
                        
                    df.dropna(inplace = True)
                    
                    print("_"*100)
                    print(f"correlation for {title} and {test[0]} - {test[1]} in {parameter} :")
                    pearsR = stats.pearsonr(df[param], df['delta'])
                    regressiveLineOrder1 = np.polynomial.polynomial.polyfit(df[param], df['delta'].astype(float), 1)
                    
                    print(f'pearson r = {pearsR[0]} (p = {pearsR[1]})')
                    linearRegLineFunction = f' y = {regressiveLineOrder1[1]} * x + {regressiveLineOrder1[0]}'
                    print(f'regressive line first order : {linearRegLineFunction}')
                    
                    fig8, ax8 = plt.subplots(figsize=(8, 8))
                    ax8.scatter(df[param], df['delta'])
                    ax8.plot(df[param], regressiveLineOrder1[1] * df[param] + regressiveLineOrder1[0],
                             '-', c = 'r', label = f'{linearRegLineFunction}')
                    ax8.set_title(f'{test[0]} - {test[1]} for {parameter} with {title} \n{pearsR}')
                    ax8.set_xlabel(f'{title}')
                    ax8.set_ylabel(f'{parameter} : {test[0]} - {test[1]}')
                    ax8.grid(True)
                    ax8.legend()
                    fig8.show()
                
            for threshold in thresholds:
                newName = lambda item : f'threshold : {int((1-threshold) * 100)}%'
                parameter = newName(threshold)
                
                if testMode:
                    print('=-'*50)
                    print('meansHR.loc[:,(parameter, test[0])]')
                    print(meansHR.loc[:,(parameter, test[0])])

                df = pd.DataFrame({test[0] : meansHR.loc[:,(parameter, test[0])],
                                  test[1] : meansHR.loc[:,(parameter, test[1])]})
                df['delta'] = df[test[0]] - df[test[1]]
                
                meanVal = np.mean(df['delta'])
                stdVal = np.std(df['delta'])
                shapiro = stats.shapiro(df['delta'].dropna())
                kurtosis = stats.kurtosistest(df['delta'].dropna())
                skew = stats.skew(df["delta"].dropna())
                if testMode or fullTestMode:
                    print('\n' * 3 + startHighlight0 + f'_ ' * 12 
                          + f'Test of Heart Rate(HR)[{parameter}] for {test[0]} - {test[1]}'
                          + f' _' * 12 + endHifghlight)
                    print('_' * 100)
                    if testMode:
                        display(df)
                        display(df.dropna())
                    print('_' * 80 + '\n')
                    print(f'mean for differences in HR[{parameter}] for {test[0]} - {test[1]} : {meanVal}')
                    print(f'standard deviation for differences in HR[{threshold}] for {test[0]} - {test[1]} : {stdVal}')
                    print('_' * 80)
                    print('Shapiro-Wilk :')
                    print(shapiro)
                    print('_'*50)
                    print('kurtosistest :')
                    print(kurtosis)
                    print('_'*50)
                    print(f'Skew : {skew}')
                    print('_'*50)
                
                fig3, ax3 = plt.subplots(figsize=(8, 8))
                ax3.hist(df['delta'].dropna(),20)
                ax3.axvline(x=meanVal, c = 'r')
                ax3.axvline(x=meanVal + stdVal, c = 'r', ls = '--')
                ax3.axvline(x=meanVal - stdVal, c = 'r', ls = '--')
                fig3.show()
                
                tTest = stats.ttest_rel(df[test[0]].dropna(), df[test[1]].dropna())
                wilcoxon = stats.wilcoxon(df[test[0]].dropna(), df[test[1]].dropna())

                print(startHighlight1 + '~' * 100 + endHifghlight)
                print(startHighlight2 + f'>>> test results of {parameter} for {test[0]} - {test[1]} : ' + endHifghlight)
                print(f'\nTtest results : {tTest}')
                print('.'*100)
                print(f'Wilcoxon signed-rank test results : {wilcoxon}\n')
                print(startHighlight1 + '~' * 100 + endHifghlight)

                results = [len(df[test[0]].dropna()),
                                  meanVal, stdVal,
                                  shapiro[0], shapiro[1], 
                                  kurtosis[0], kurtosis[1], skew,
                                  tTest[0], tTest[1],
                                  wilcoxon[0], wilcoxon[1]]

                i = 0
                for colName in columnNames:
                    resultsDF.loc[(outerI, parameter), colName] = results[i]
                    i += 1
                
                #added for correlations:                
                for param in correls:
                    if param == 'Phases lengths':                        
                        df[param] = meansSC.loc[:,(param, 'break')]
                        title = 'Break length[s]'
                    else:
                        df[param] = meansSC.loc[:,param]
                        title = param
                        
                    df.dropna(inplace = True)
                    
                    print("_"*100)
                    print(f"correlation for {title} and {test[0]} - {test[1]} in Heart Rate(HR)[{parameter}] :")
                    pearsR = stats.pearsonr(df[param], df['delta'])
                    regressiveLineOrder1 = np.polynomial.polynomial.polyfit(df[param], df['delta'].astype(float), 1)
                    
                    print(f'pearson r = {pearsR[0]} (p = {pearsR[1]})')
                    linearRegLineFunction = f' y = {regressiveLineOrder1[1]} * x + {regressiveLineOrder1[0]}'
                    print(f'regressive line first order : {linearRegLineFunction}')
                    
                    fig8, ax8 = plt.subplots(figsize=(8, 8))
                    ax8.scatter(df[param], df['delta'])
                    ax8.plot(df[param], regressiveLineOrder1[1] * df[param] + regressiveLineOrder1[0],
                             '-', c = 'r', label = f'{linearRegLineFunction}')
                    ax8.set_title(f'{test[0]} - {test[1]} for {parameter} with {title} \n{pearsR}')
                    ax8.set_xlabel(f'{title}')
                    ax8.set_ylabel(f'{parameter} : {test[0]} - {test[1]}')
                    ax8.grid(True)
                    ax8.legend()
                    fig8.show()
                
        if testMode or fullTestMode:    
            print(f"\nstatisticalTestsOnData in {time.perf_counter() - start}s")
            
        return resultsDF
    
    except Exception as e:
        print("error in statisticalTestsOnData")
        print(e)


def saveResults(statisticalResults, meansSC, meansHR, ageDF, pathToSaveData = 'Results/'):
    try:
        filePath = pathToSaveData + 'ExperimentResults.xlsx'
        with pd.ExcelWriter(os.path.join(os.getcwd(),filePath)) as writer:
            statisticalResults.to_excel(writer, sheet_name='Statistical Results')
            meansHR.to_excel(writer, sheet_name='Means Heart Rate')
            meansSC.to_excel(writer, sheet_name='Means Skin Conductance')
            ageDF.to_excel(writer, sheet_name='Means Age')
            
    except Exception as e:
        print("error in saveResults")
        print(e)


def main(experimentDataList, testMode = False, devMode = False):
    try:
        if testMode or fullTestMode:
            start = time.perf_counter()
            
        randomSample = False

        pd.options.display.max_rows = 100
        pd.options.display.float_format = '{:.3f}'.format

        thresholds = [1, .9, .5, .1]

        AllParticipantsGr = {'0002':2,'0003':1,'0004':2,'0005':2,'0006':1,'0007':1,'0008':1,'0009':2,'0010':2,
                         '0011':2,'0012':2,'0013':2,'0014':1,'0015':2,'0016':1,'0017':2,'0018':2,'0019':2,'0020':1,
                         '0021':2,'0022':1,'0023':1,'0024':1,'0025':1,'0026':1,'0027':1,'0028':1,'0029':2,'0030':1,
                         '0032':2,'0033':2,'0034':2,'0035':1,'0036':2,'0037':1,'0038':1,'0039':2,'0040':2,
                         '0041':2,'0042':2,'0043':1,'0044':2,'0045':1,'0046':1,'0047':1,'0048':1,'0049':2,'0050':1,
                         '0051':1,'0052':1,'0053':2,'0054':2,'0055':2,'0056':1,'0057':1,'0058':1,'0059':1,'0060':2,
                         '0061':2,'0062':2,'0063':1,
                         '0071':2,'0072':1,'0073':2
                        }

        if randomSample:
            numberOfRandomSamples = 4
            randoms = random.sample(range(0, len(AllParticipantsGr)), numberOfRandomSamples)
            AllParticipantsGrList = list(AllParticipantsGr)
            newDict = {}
            for item in randoms:
                keys = AllParticipantsGrList[item]
                newDict[keys] = AllParticipantsGr.get(keys)
            AllParticipantsGr = newDict
        
        if not devMode:
            experimentDataList = readAllData(AllParticipantsGr)

        ageDF = calculateMeanAge(experimentDataList)
        
        experimentDataListProcessed = getIndexForPhase(experimentDataList)
        
        experimentDataListProcessed = testingHRQualityPerSample(experimentDataListProcessed, showGraphs = True)
        
        meansHR, meansSC = calculateMeansPerPhase(experimentDataListProcessed, thresholds = thresholds)
        
        statisticalResults = statisticalTestsOnData(meansSC, meansHR, thresholds = thresholds, testMode = False)
        
        saveResults(statisticalResults, meansSC, meansHR, ageDF)
        
        if testMode or fullTestMode: 
            display(statisticalResults)   
            print(f"\nmain in {time.perf_counter() - start}s")
    
    except Exception as e:
        print("error in main")
        print(e)


devMode = True


global experimentDataList

if devMode:
    AllParticipantsGr = {'0002':2,'0003':1,'0004':2,'0005':2,'0006':1,'0007':1,'0008':1,'0009':2,'0010':2,
                         '0011':2,'0012':2,'0013':2,'0014':1,'0015':2,'0016':1,'0017':2,'0018':2,'0019':2,'0020':1,
                         '0021':2,'0022':1,'0023':1,'0024':1,'0025':1,'0026':1,'0027':1,'0028':1,'0029':2,'0030':1,
                         '0032':2,'0033':2,'0034':2,'0035':1,'0036':2,'0037':1,'0038':1,'0039':2,'0040':2,
                         '0041':2,'0042':2,'0043':1,'0044':2,'0045':1,'0046':1,'0047':1,'0048':1,'0049':2,'0050':1,
                         '0051':1,'0052':1,'0053':2,'0054':2,'0055':2,'0056':1,'0057':1,'0058':1,'0059':1,'0060':2,
                         '0061':2,'0062':2,'0063':1,
                         '0071':2,'0072':1,'0073':2
                        }
    experimentDataList = readAllData(AllParticipantsGr)
#else: # maybe check if empty ???
    #experimentDataList = []


fullTestMode = True


if __name__ == "__main__":
    main(experimentDataList, testMode = False, devMode = devMode)

Average participant age : 28.71875
Standard deviation of participant age : 10.479844867053139
Median of participant age : 25.0
N = 64
________________________________________________________________________________
Mean female age : 29.03125
Standard deviation of female age : 11.114417368332898
Median of female age : 24.0
N = 32

Mean male age : 28.40625
Standard deviation of male age : 9.794320340763825
Median of male age : 25.5
N = 32

calculateMeanAge in 0.029754100018180907s
____________________________________________________________________________________________________
Shortest break : 15.06
Longest break : 82.5
________________________________________________________________________________
Mean break length : 37.819218750000005
SD break length : 13.889500452757416
________________________________________
Median break length : 36.905
Q1 and Q3 break : [27.52 44.6 ]

getIndexForPhase in 7.868109200033359s

testingHRQualityPerSample in 0.7257573999813758s
____________________________________________________________________________________________________
meansHR :

____________________________________________________________________________________________________

meansSC :

calculateMeansPerPhase in 0.6135291999671608s


_ _ _ _ _ _ _ _ _ _ _ _ Test of Skin Conductance for : adaptation PE - instruction _ _ _ _ _ _ _ _ _ _ _ _
____________________________________________________________________________________________________
________________________________________________________________________________

mean for differences in Skin Conductance for adaptation PE - instruction : -0.04158676492803516
standard deviation for differences in Skin Conductance for adaptation PE - instruction : 0.2762758884200016
________________________________________________________________________________
Shapiro-Wilk :
ShapiroResult(statistic=0.9399993419647217, pvalue=0.00379479443654418)
__________________________________________________
kurtosistest :
KurtosistestResult(statistic=2.8554775596213147, pvalue=0.0042972159502872274)
__________________________________________________
Skew : -1.0244087325216287
__________________________________________________

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>>> test results of Skin Conductance for adaptation PE - instruction : 

Ttest results : Ttest_relResult(statistic=-1.1947648250507066, pvalue=0.23665753802076023)
....................................................................................................
Wilcoxon signed-rank test results : WilcoxonResult(statistic=943.0, pvalue=0.5165400906836031)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
____________________________________________________________________________________________________
correlation for Break length[s] and adaptation PE - instruction in Skin Conductance :
pearson r = 0.22495728455619718 (p = 0.07390967004398297)
regressive line first order :  y = 0.004474622673342874 * x + -0.21081349863489893

____________________________________________________________________________________________________
correlation for Age and adaptation PE - instruction in Skin Conductance :
pearson r = -0.049799036167205685 (p = 0.6959577028131353)
regressive line first order :  y = -0.001312831738836924 * x + -0.0038838784283122324

____________________________________________________________________________________________________
correlation for MSSQ and adaptation PE - instruction in Skin Conductance :
pearson r = 0.1166206671269302 (p = 0.3587686259476603)
regressive line first order :  y = 0.0013833121705076681 * x + -0.06933946534884519



_ _ _ _ _ _ _ _ _ _ _ _ Test of Phasic Component for : adaptation PE - instruction _ _ _ _ _ _ _ _ _ _ _ _
____________________________________________________________________________________________________
________________________________________________________________________________

mean for differences in Phasic Component for adaptation PE - instruction : -1.0591250391742832
standard deviation for differences in Phasic Component for adaptation PE - instruction : 2.5674681440788514
________________________________________________________________________________
Shapiro-Wilk :
ShapiroResult(statistic=0.3989065885543823, pvalue=9.638019447474628e-15)
__________________________________________________
kurtosistest :
KurtosistestResult(statistic=5.78967274344623, pvalue=7.052369382028885e-09)
__________________________________________________
Skew : -4.409717522049862
__________________________________________________

	threshold : 0%				threshold : 9%				threshold : 50%		...	targeted threshold : 90%		Phases lengths				Gender	Age	MSSQ	ID
	adaptation PE	instruction	break	adaptation VE	adaptation PE	instruction	break	adaptation VE	adaptation PE	instruction	...	break	adaptation VE	adaptation PE	instruction	break	adaptation VE
0	85.236	83.382	101.932	92.675	85.236	83.382	101.932	92.675	85.236	83.382	...	NaN	NaN	90.010	15.960	38.290	89.990	1.000	21.000	29.000	2.000
1	101.153	102.931	118.315	109.265	101.153	102.931	118.315	109.265	NaN	NaN	...	NaN	NaN	90.010	15.940	36.890	89.990	1.000	19.000	45.000	3.000
2	76.114	79.260	94.969	78.355	76.114	79.260	94.969	78.355	76.114	79.260	...	NaN	NaN	90.010	15.940	15.060	89.980	1.000	42.000	41.000	4.000
3	90.888	99.455	102.640	89.783	90.888	99.455	102.640	89.783	90.888	99.455	...	102.640	89.783	90.010	15.940	28.130	89.980	1.000	23.000	0.000	5.000
4	73.799	87.859	86.673	74.219	73.799	87.859	86.673	74.219	73.799	87.859	...	NaN	74.219	90.010	15.950	29.340	89.980	1.000	21.000	10.000	6.000
5	79.555	78.763	92.231	79.915	79.555	78.763	92.231	79.915	79.555	78.763	...	92.231	79.915	90.000	15.950	46.820	89.980	1.000	34.000	0.000	7.000
6	90.530	124.432	119.617	91.481	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	90.010	15.930	37.060	89.990	1.000	18.000	10.000	8.000
7	70.301	80.795	117.689	68.245	70.301	80.795	117.689	68.245	NaN	NaN	...	NaN	NaN	90.010	15.970	36.010	89.980	1.000	19.000	0.000	9.000
8	79.088	81.571	87.270	74.460	79.088	81.571	87.270	74.460	79.088	81.571	...	NaN	74.460	90.010	15.950	33.420	89.980	1.000	37.000	0.000	10.000
9	70.492	79.437	79.064	68.414	70.492	79.437	79.064	68.414	70.492	79.437	...	79.064	68.414	90.010	15.930	37.320	89.990	1.000	36.000	29.000	11.000
10	59.377	60.844	83.050	59.550	59.377	60.844	83.050	59.550	NaN	NaN	...	NaN	NaN	90.010	15.950	44.600	89.980	1.000	34.000	61.000	12.000
11	60.795	62.545	68.301	58.271	60.795	62.545	68.301	58.271	60.795	62.545	...	NaN	58.271	90.010	15.950	69.340	89.980	1.000	56.000	30.000	13.000
12	59.112	61.374	70.564	58.074	59.112	61.374	70.564	58.074	59.112	61.374	...	NaN	58.074	90.000	15.980	34.400	89.990	1.000	32.000	81.000	14.000
13	71.382	85.782	97.895	98.323	71.382	85.782	97.895	98.323	NaN	NaN	...	NaN	NaN	90.010	15.950	27.220	89.980	1.000	21.000	0.000	15.000
14	66.578	75.552	81.535	64.677	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	90.010	15.960	22.860	89.990	1.000	25.000	0.000	16.000
15	81.326	86.189	96.499	78.064	81.326	86.189	96.499	78.064	81.326	86.189	...	NaN	78.064	90.010	15.920	29.310	90.000	1.000	22.000	20.000	17.000
16	85.046	93.154	156.897	157.215	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	90.000	15.970	60.220	89.980	1.000	19.000	69.000	18.000
17	61.917	59.502	74.137	64.656	61.917	59.502	74.137	64.656	NaN	NaN	...	NaN	NaN	90.000	15.970	38.100	89.990	1.000	36.000	45.000	19.000
18	108.361	115.214	133.078	104.255	108.361	115.214	133.078	104.255	108.361	115.214	...	NaN	104.255	90.000	15.970	27.750	89.990	1.000	23.000	0.000	20.000
19	66.279	63.632	81.327	66.092	66.279	63.632	81.327	66.092	66.279	63.632	...	NaN	66.092	90.010	15.940	57.800	89.980	1.000	29.000	56.000	21.000
20	70.996	75.160	82.369	73.624	70.996	75.160	82.369	73.624	70.996	75.160	...	82.369	73.624	90.010	15.930	53.270	89.990	1.000	29.000	0.000	22.000
21	63.246	70.250	75.047	64.154	63.246	70.250	75.047	64.154	63.246	70.250	...	NaN	64.154	90.010	15.940	58.310	89.980	1.000	55.000	10.000	23.000
22	75.215	74.492	82.492	73.516	75.215	74.492	82.492	73.516	75.215	74.492	...	82.492	73.516	90.010	15.940	82.500	89.980	1.000	53.000	89.000	24.000
23	91.640	104.832	112.660	92.141	91.640	104.832	112.660	92.141	NaN	NaN	...	NaN	92.141	90.000	15.960	29.410	89.980	1.000	41.000	0.000	25.000
24	73.494	74.361	87.418	75.076	73.494	74.361	87.418	75.076	73.494	74.361	...	NaN	75.076	90.010	15.960	23.420	89.970	1.000	41.000	41.000	26.000
25	68.106	78.410	140.570	91.677	68.106	78.410	140.570	91.677	NaN	NaN	...	NaN	NaN	90.010	15.940	25.500	89.990	1.000	21.000	51.000	27.000
26	91.405	93.378	128.038	88.546	91.405	93.378	128.038	88.546	NaN	NaN	...	NaN	88.546	90.010	15.950	33.320	89.980	1.000	19.000	35.000	28.000
27	90.982	90.850	102.663	92.380	90.982	90.850	102.663	92.380	90.982	90.850	...	NaN	92.380	90.010	15.940	40.290	89.980	1.000	19.000	37.000	29.000
28	103.072	86.465	94.188	88.042	103.072	86.465	94.188	88.042	NaN	NaN	...	NaN	NaN	90.020	15.950	51.160	89.980	1.000	19.000	0.000	30.000
29	75.621	70.590	97.271	77.279	75.621	70.590	97.271	77.279	75.621	70.590	...	NaN	77.279	90.010	15.960	29.230	89.990	0.000	30.000	0.000	32.000
30	87.902	99.117	107.438	93.139	87.902	99.117	107.438	93.139	NaN	NaN	...	NaN	93.139	90.010	15.930	39.320	89.990	0.000	20.000	49.000	33.000
31	63.758	78.770	94.701	55.395	63.758	78.770	94.701	55.395	63.758	78.770	...	NaN	55.395	90.000	15.960	24.580	89.970	0.000	20.000	11.000	34.000
32	84.639	86.959	92.363	86.833	84.639	86.959	92.363	86.833	NaN	NaN	...	NaN	NaN	90.010	15.940	26.760	89.980	0.000	20.000	29.000	35.000
33	63.586	65.042	78.221	63.294	63.586	65.042	78.221	63.294	NaN	NaN	...	NaN	63.294	90.000	15.980	33.690	89.990	0.000	27.000	10.000	36.000
34	84.891	84.008	86.258	82.967	84.891	84.008	86.258	82.967	84.891	84.008	...	NaN	82.967	90.010	15.950	27.620	89.980	0.000	19.000	45.000	37.000
35	79.653	84.339	103.334	176.380	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	89.990	15.950	30.080	89.980	0.000	19.000	33.000	38.000
36	92.462	93.509	112.415	96.702	92.462	93.509	112.415	96.702	92.462	93.509	...	NaN	96.702	90.010	15.930	57.560	89.980	0.000	23.000	0.000	39.000
37	71.710	70.785	83.848	74.510	71.710	70.785	83.848	74.510	71.710	70.785	...	NaN	NaN	90.000	15.960	21.540	89.990	0.000	34.000	5.000	40.000
38	79.336	86.487	98.962	79.810	79.336	86.487	98.962	79.810	79.336	86.487	...	NaN	79.810	90.010	15.970	19.830	89.980	0.000	41.000	20.000	41.000
39	76.486	78.736	110.618	94.243	76.486	78.736	110.618	94.243	NaN	NaN	...	NaN	NaN	90.010	15.930	39.400	89.980	0.000	19.000	10.000	42.000
40	57.317	57.628	64.330	57.190	57.317	57.628	64.330	57.190	57.317	57.628	...	NaN	57.190	90.000	15.940	17.010	89.980	0.000	59.000	29.000	43.000
41	76.426	80.515	124.975	91.202	76.426	80.515	124.975	91.202	NaN	NaN	...	NaN	NaN	90.010	15.930	23.690	89.990	0.000	34.000	44.000	44.000
42	78.259	80.652	88.259	74.167	78.259	80.652	88.259	74.167	78.259	80.652	...	NaN	74.167	90.000	15.980	50.000	89.980	0.000	35.000	0.000	45.000
43	111.003	112.192	174.618	164.242	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	90.000	15.960	43.360	89.980	0.000	47.000	0.000	46.000
44	57.534	63.060	67.108	57.773	57.534	63.060	67.108	57.773	57.534	63.060	...	NaN	57.773	90.010	15.950	36.920	89.990	0.000	35.000	0.000	47.000
45	80.055	106.873	78.157	69.742	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	89.980	15.940	44.600	89.980	0.000	22.000	10.000	48.000
46	69.141	74.775	78.541	72.868	69.141	74.775	78.541	72.868	69.141	74.775	...	NaN	72.868	90.000	15.940	34.340	89.990	0.000	33.000	0.000	49.000
47	62.515	62.301	115.804	59.010	62.515	62.301	115.804	59.010	NaN	NaN	...	NaN	NaN	90.010	15.950	31.830	89.990	0.000	29.000	66.000	50.000
48	66.346	71.146	127.744	67.197	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	67.197	90.010	15.950	37.620	89.980	0.000	33.000	0.000	51.000
49	78.854	87.195	112.294	75.585	78.854	87.195	112.294	75.585	NaN	NaN	...	NaN	75.585	90.010	15.930	40.740	89.990	0.000	25.000	0.000	52.000
50	70.607	70.246	78.726	69.529	70.607	70.246	78.726	69.529	70.607	70.246	...	78.726	69.529	90.010	15.960	23.610	89.980	0.000	25.000	59.000	53.000
51	62.050	65.298	72.020	60.224	62.050	65.298	72.020	60.224	62.050	65.298	...	NaN	60.224	90.010	15.920	20.800	89.990	0.000	50.000	5.000	54.000
52	82.003	82.152	85.867	74.750	82.003	82.152	85.867	74.750	82.003	82.152	...	NaN	74.750	90.010	15.950	24.220	89.980	0.000	30.000	5.000	55.000
53	69.640	75.352	80.205	71.341	69.640	75.352	80.205	71.341	NaN	NaN	...	NaN	NaN	90.010	15.940	24.650	89.970	0.000	31.000	0.000	56.000
54	81.271	78.429	84.813	73.274	81.271	78.429	84.813	73.274	NaN	NaN	...	NaN	73.274	90.010	15.960	25.870	89.990	0.000	21.000	10.000	57.000
55	72.445	75.038	98.079	68.687	72.445	75.038	98.079	68.687	NaN	NaN	...	NaN	NaN	90.010	15.930	47.130	89.980	0.000	19.000	0.000	58.000
56	58.405	60.180	66.696	64.070	58.405	60.180	66.696	64.070	58.405	60.180	...	NaN	NaN	90.010	15.960	61.980	89.980	0.000	20.000	10.000	59.000
57	69.552	75.274	108.314	78.068	69.552	75.274	108.314	78.068	NaN	NaN	...	NaN	NaN	90.010	15.960	37.190	89.980	0.000	22.000	5.000	60.000
58	100.218	112.117	129.842	101.955	100.218	112.117	129.842	101.955	100.218	112.117	...	NaN	101.955	90.010	15.930	42.980	89.980	1.000	25.000	10.000	61.000
59	70.417	75.459	86.857	74.112	70.417	75.459	86.857	74.112	70.417	75.459	...	86.857	74.112	90.010	15.920	44.720	89.980	1.000	21.000	10.000	62.000
60	97.476	96.021	107.763	90.689	97.476	96.021	107.763	90.689	97.476	96.021	...	107.763	90.689	90.010	15.960	65.550	89.990	1.000	19.000	0.000	63.000
61	75.240	76.567	89.926	75.612	75.240	76.567	89.926	75.612	75.240	76.567	...	89.926	75.612	90.010	15.920	37.480	89.990	0.000	21.000	10.000	71.000
62	84.669	85.627	95.045	84.156	84.669	85.627	95.045	84.156	NaN	NaN	...	NaN	84.156	90.010	15.940	40.590	89.980	0.000	26.000	10.000	72.000
63	182.615	142.365	102.136	64.389	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	90.010	15.950	66.820	89.980	0.000	20.000	0.000	73.000

	Skin Conductance				Phasic Component				Tonic Component				Phases lengths				Gender	Age	MSSQ	ID
	adaptation PE	instruction	break	adaptation VE	adaptation PE	instruction	break	adaptation VE	adaptation PE	instruction	break	adaptation VE	adaptation PE	instruction	break	adaptation VE
0	1.558	1.302	1.332	1.425	0.081	0.162	0.576	0.157	0.839	-0.395	-0.675	0.164	90.010	15.960	38.290	89.990	1.000	21.000	29.000	2.000
1	1.989	2.130	2.049	2.022	0.112	0.680	0.618	0.214	0.757	0.690	0.465	0.774	90.010	15.940	36.890	89.990	1.000	19.000	45.000	3.000
2	1.133	1.169	1.394	1.173	0.076	1.208	2.151	0.059	0.837	-0.159	-0.258	1.005	90.010	15.940	15.060	89.980	1.000	42.000	41.000	4.000
3	3.131	3.473	4.491	4.543	0.134	0.593	1.287	0.707	-1.497	-1.408	-0.471	0.192	90.010	15.940	28.130	89.980	1.000	23.000	0.000	5.000
4	1.960	2.055	3.132	2.220	0.020	0.393	0.761	0.025	0.390	0.212	2.054	0.918	90.010	15.950	29.340	89.980	1.000	21.000	10.000	6.000
5	1.346	1.397	1.839	1.739	0.108	0.476	0.971	0.104	-0.341	-0.506	0.753	1.224	90.000	15.950	46.820	89.980	1.000	34.000	0.000	7.000
6	2.904	2.647	2.653	2.580	0.081	0.047	0.139	0.077	1.246	0.788	0.706	0.630	90.010	15.930	37.060	89.990	1.000	18.000	10.000	8.000
7	0.356	0.313	0.467	0.431	0.014	0.076	0.595	0.005	0.644	0.162	1.147	1.391	90.010	15.970	36.010	89.980	1.000	19.000	0.000	9.000
8	2.158	1.979	1.953	1.955	0.044	0.289	4.055	0.037	1.602	0.655	-3.209	0.817	90.010	15.950	33.420	89.980	1.000	37.000	0.000	10.000
9	1.988	2.266	2.770	2.443	0.034	0.403	0.430	0.056	0.667	0.678	1.341	1.268	90.010	15.930	37.320	89.990	1.000	36.000	29.000	11.000
10	1.394	1.259	1.362	1.642	0.043	0.135	0.401	0.064	-1.143	-1.810	-1.638	-0.103	90.010	15.950	44.600	89.980	1.000	34.000	61.000	12.000
11	0.904	0.895	0.993	0.998	0.026	0.398	3.696	0.062	0.307	-0.153	-2.408	1.277	90.010	15.950	69.340	89.980	1.000	56.000	30.000	13.000
12	1.612	1.571	1.818	1.983	0.074	0.849	5.836	0.328	0.305	-0.610	-4.764	1.305	90.000	15.980	34.400	89.990	1.000	32.000	81.000	14.000
13	2.199	2.298	2.330	2.780	0.148	0.669	2.393	0.392	-0.655	-0.869	-2.497	0.896	90.010	15.950	27.220	89.980	1.000	21.000	0.000	15.000
14	4.287	3.873	3.976	3.613	0.293	2.883	7.547	0.575	1.286	-1.958	-6.459	-0.061	90.010	15.960	22.860	89.990	1.000	25.000	0.000	16.000
15	4.503	4.803	5.273	4.993	0.379	0.427	0.404	0.091	0.203	0.457	0.955	0.986	90.010	15.920	29.310	90.000	1.000	22.000	20.000	17.000
16	1.154	0.989	1.489	1.502	0.050	0.062	0.526	0.051	-0.043	-0.690	0.770	1.296	90.000	15.970	60.220	89.980	1.000	19.000	69.000	18.000
17	1.364	0.956	0.840	0.890	0.031	0.136	0.700	0.057	1.972	0.442	-0.527	0.290	90.000	15.970	38.100	89.990	1.000	36.000	45.000	19.000
18	2.667	2.968	4.469	2.808	0.053	0.533	1.011	0.016	0.856	0.646	1.509	1.020	90.000	15.970	27.750	89.990	1.000	23.000	0.000	20.000
19	1.065	1.009	1.343	1.409	0.202	0.038	4.043	0.767	-1.787	-2.065	-3.462	0.334	90.010	15.940	57.800	89.980	1.000	29.000	56.000	21.000
20	0.777	0.682	1.043	1.172	0.333	1.153	4.438	0.110	-0.578	-1.801	-3.564	1.308	90.010	15.930	53.270	89.990	1.000	29.000	0.000	22.000
21	4.003	4.676	4.189	4.410	0.495	1.989	0.977	0.550	0.091	-0.530	-0.150	0.563	90.010	15.940	58.310	89.980	1.000	55.000	10.000	23.000
22	1.536	1.142	1.329	1.199	0.003	0.041	0.121	0.001	1.576	0.460	0.892	0.656	90.010	15.940	82.500	89.980	1.000	53.000	89.000	24.000
23	1.888	1.812	2.775	2.048	0.080	1.237	1.241	0.062	0.565	-0.759	1.363	0.937	90.000	15.960	29.410	89.980	1.000	41.000	0.000	25.000
24	4.375	4.164	6.932	4.268	0.068	0.441	0.958	0.072	0.923	0.405	1.782	0.846	90.010	15.960	23.420	89.970	1.000	41.000	41.000	26.000
25	1.356	1.306	1.784	1.752	0.083	0.384	1.899	0.473	-0.828	-1.355	-0.706	0.576	90.010	15.940	25.500	89.990	1.000	21.000	51.000	27.000
26	3.230	3.727	4.812	3.437	0.045	0.389	0.794	0.041	0.702	0.832	1.459	0.904	90.010	15.950	33.320	89.980	1.000	19.000	35.000	28.000
27	1.974	2.109	2.253	2.367	0.249	1.041	0.440	0.149	0.361	-0.170	0.712	1.223	90.010	15.940	40.290	89.980	1.000	19.000	37.000	29.000
28	5.267	5.451	6.971	6.766	0.216	0.403	1.378	0.340	-1.670	-1.591	-0.368	0.373	90.020	15.950	51.160	89.980	1.000	19.000	0.000	30.000
29	1.582	1.662	1.779	1.851	0.317	0.612	2.589	0.620	-1.684	-1.260	-2.183	0.442	90.010	15.960	29.230	89.990	0.000	30.000	0.000	32.000
30	1.090	1.205	1.248	1.289	1.208	1.011	2.112	0.561	-2.984	-1.353	-1.918	0.156	90.010	15.930	39.320	89.990	0.000	20.000	49.000	33.000
31	1.527	1.553	1.415	1.460	0.708	8.591	24.643	0.744	-1.024	-8.600	-26.269	-1.850	90.000	15.960	24.580	89.970	0.000	20.000	11.000	34.000
32	2.678	3.021	2.999	3.022	0.146	2.137	4.752	0.264	0.519	-0.885	-3.539	0.988	90.010	15.940	26.760	89.980	0.000	20.000	29.000	35.000
33	0.799	0.746	0.980	1.006	0.046	0.125	1.251	0.117	0.523	0.189	0.189	1.447	90.000	15.980	33.690	89.990	0.000	27.000	10.000	36.000
34	6.765	7.206	8.117	7.478	0.304	0.495	0.843	0.058	0.154	0.387	0.914	1.085	90.010	15.950	27.620	89.980	0.000	19.000	45.000	37.000
35	5.894	6.239	6.807	6.822	0.430	0.654	1.609	0.342	-1.471	-1.353	-1.743	-0.462	89.990	15.950	30.080	89.980	0.000	19.000	33.000	38.000
36	1.324	1.356	1.577	1.718	0.127	0.497	0.858	0.072	-2.070	-2.277	-1.513	-0.011	90.010	15.930	57.560	89.980	0.000	23.000	0.000	39.000
37	0.434	0.414	0.380	0.375	0.374	0.841	15.722	0.371	0.381	-0.788	-16.875	-1.689	90.000	15.960	21.540	89.990	0.000	34.000	5.000	40.000
38	3.549	4.685	4.904	4.283	0.181	1.410	2.045	0.675	-1.112	-0.392	-0.652	-0.347	90.010	15.970	19.830	89.980	0.000	41.000	20.000	41.000
39	1.516	1.527	1.626	1.645	1.692	1.357	11.379	3.308	-3.203	-2.772	-11.889	-3.647	90.010	15.930	39.400	89.980	0.000	19.000	10.000	42.000
40	1.943	1.887	2.665	2.602	0.035	0.204	0.567	0.115	0.256	-0.021	1.104	1.437	90.000	15.940	17.010	89.980	0.000	59.000	29.000	43.000
41	1.798	1.870	1.713	2.221	0.099	2.199	30.598	3.625	-0.289	-2.087	-31.147	-2.031	90.010	15.930	23.690	89.990	0.000	34.000	44.000	44.000
42	2.149	2.071	2.267	1.897	0.133	1.331	4.897	0.043	1.210	-0.364	-2.984	0.084	90.000	15.980	50.000	89.980	0.000	35.000	0.000	45.000
43	1.626	1.350	2.432	2.430	0.022	0.287	0.778	0.206	0.242	-0.464	0.776	1.345	90.000	15.960	43.360	89.980	0.000	47.000	0.000	46.000
44	2.264	2.637	3.454	2.673	0.115	1.323	1.431	0.289	-1.251	-1.318	1.081	-0.171	90.010	15.950	36.920	89.990	0.000	35.000	0.000	47.000
45	1.566	1.588	1.591	1.657	3.382	3.169	24.385	0.820	-4.794	-4.034	-25.172	0.060	89.980	15.940	44.600	89.980	0.000	22.000	10.000	48.000
46	4.024	3.952	4.166	3.905	0.278	0.772	0.929	0.272	0.144	-0.587	-0.032	-0.242	90.000	15.940	34.340	89.990	0.000	33.000	0.000	49.000
47	1.679	1.577	1.826	1.773	0.344	0.938	1.945	0.237	0.590	-0.270	-0.631	0.940	90.010	15.950	31.830	89.990	0.000	29.000	66.000	50.000
48	2.647	3.089	3.957	3.033	0.005	0.951	0.750	0.037	0.336	0.103	1.703	0.928	90.010	15.950	37.620	89.980	0.000	33.000	0.000	51.000
49	2.877	3.068	3.475	3.406	0.070	0.536	0.750	0.095	0.128	0.022	0.573	1.098	90.010	15.930	40.740	89.990	0.000	25.000	0.000	52.000
50	1.179	1.108	1.118	1.147	0.313	2.456	1.198	0.892	1.138	-2.532	-1.071	-0.131	90.010	15.960	23.610	89.980	0.000	25.000	59.000	53.000
51	3.015	3.490	3.910	3.011	0.225	12.400	8.700	0.242	-0.624	-11.412	-6.488	-0.652	90.010	15.920	20.800	89.990	0.000	50.000	5.000	54.000
52	1.453	1.440	1.480	1.521	0.040	0.995	1.303	0.234	0.797	-0.259	-0.254	1.128	90.010	15.950	24.220	89.980	0.000	30.000	5.000	55.000
53	0.934	0.964	1.113	1.111	0.161	0.662	0.888	0.335	0.112	-0.191	0.579	1.118	90.010	15.940	24.650	89.970	0.000	31.000	0.000	56.000
54	5.056	5.342	5.405	4.904	0.262	0.794	0.676	0.200	-1.119	-1.072	-0.826	-1.366	90.010	15.960	25.870	89.990	0.000	21.000	10.000	57.000
55	1.772	1.657	1.726	1.509	0.020	0.445	1.828	0.093	1.533	0.655	-0.456	0.420	90.010	15.930	47.130	89.980	0.000	19.000	0.000	58.000
56	0.710	0.655	1.099	0.982	0.026	0.208	0.314	0.091	-0.169	-0.647	1.629	1.225	90.010	15.960	61.980	89.980	0.000	20.000	10.000	59.000
57	6.654	6.132	7.118	6.761	0.030	0.102	0.469	0.033	0.951	0.366	0.969	1.053	90.010	15.960	37.190	89.980	0.000	22.000	5.000	60.000
58	4.794	4.795	5.050	5.626	0.404	1.378	2.626	0.496	-1.069	-2.041	-2.855	0.257	90.010	15.930	42.980	89.980	1.000	25.000	10.000	61.000
59	4.832	4.543	6.456	5.628	0.302	0.508	0.851	0.279	-0.136	-0.635	0.970	0.699	90.010	15.920	44.720	89.980	1.000	21.000	10.000	62.000
60	9.036	9.185	9.305	9.226	0.183	0.395	2.971	0.107	-0.974	-0.799	-3.064	-0.406	90.010	15.960	65.550	89.990	1.000	19.000	0.000	63.000
61	2.497	2.230	2.629	2.731	0.195	15.850	23.912	1.518	-0.296	-16.806	-23.590	-0.869	90.010	15.920	37.480	89.990	0.000	21.000	10.000	71.000
62	3.222	2.998	3.496	3.288	0.084	0.204	0.421	0.158	0.831	0.414	0.857	0.844	90.010	15.940	40.590	89.980	0.000	26.000	10.000	72.000
63	1.263	1.222	1.409	1.848	0.031	0.283	0.318	0.096	-1.098	-1.514	-0.798	1.196	90.010	15.950	66.820	89.980	0.000	20.000	0.000	73.000

		N	mean difference	standard deviation	Shapiro-Wilk statistic	Shapiro-Wilk pvalue	kurtosis statistic	kurtosis pvalue	skew	Ttest statistic	Ttest pvalue	Wilcoxon statistic	Wilcoxon pvalue
adaptation PE - instruction	threshold : 0%	64	-3.673	8.922	0.792	0.000	4.811	0.000	1.068	-3.268	0.002	329.000	0.000
	threshold : 9%	56	-3.337	5.433	0.936	0.005	2.454	0.014	0.264	-4.555	0.000	252.000	0.000
	threshold : 50%	35	-3.162	4.574	0.940	0.057	0.883	0.377	-0.836	-4.031	0.000	103.000	0.001
	threshold : 90%	5	-2.551	3.759	0.918	0.515	-0.519	0.604	-0.496	-1.357	0.246	4.000	0.438
adaptation PE - break	threshold : 0%	64	-18.642	20.914	0.806	0.000	4.394	0.000	0.749	-7.075	0.000	79.000	0.000
	threshold : 9%	56	-18.051	13.950	0.855	0.000	3.104	0.002	-1.594	-9.596	0.000	12.000	0.000
	threshold : 50%	35	-13.214	6.416	0.925	0.019	1.517	0.129	-0.989	-12.009	0.000	0.000	0.000
	threshold : 90%	5	-12.088	3.231	0.980	0.935	-0.478	0.633	0.103	-7.483	0.002	0.000	0.062
adaptation PE - adaptation VE	threshold : 0%	64	-2.437	23.004	0.555	0.000	5.438	0.000	0.555	-0.841	0.404	944.000	0.521
	threshold : 9%	56	-1.115	6.930	0.850	0.000	3.441	0.001	-1.551	-1.193	0.238	738.000	0.625
	threshold : 50%	35	0.300	3.463	0.984	0.890	0.537	0.591	0.260	0.505	0.617	298.000	0.781
	threshold : 90%	5	1.105	3.402	0.964	0.832	0.740	0.459	0.355	0.650	0.551	5.000	0.625
instruction - break	threshold : 0%	64	-14.969	17.985	0.859	0.000	2.732	0.006	-0.618	-6.606	0.000	123.000	0.000
	threshold : 9%	56	-14.715	12.599	0.821	0.000	3.175	0.001	-1.801	-8.661	0.000	3.000	0.000
	threshold : 50%	35	-10.052	6.110	0.974	0.577	0.330	0.742	-0.410	-9.594	0.000	3.000	0.000
	threshold : 90%	5	-9.537	3.623	0.895	0.383	0.410	0.682	0.786	-5.264	0.006	0.000	0.062
instruction - adaptation VE	threshold : 0%	64	1.237	20.545	0.710	0.000	4.766	0.000	-1.268	0.478	0.634	692.000	0.020
	threshold : 9%	56	2.222	7.161	0.979	0.451	1.338	0.181	-0.083	2.301	0.025	494.000	0.013
	threshold : 50%	35	3.462	6.212	0.963	0.277	1.846	0.065	0.695	3.250	0.003	134.000	0.003
	threshold : 90%	5	3.656	3.430	0.797	0.076	0.240	0.810	0.848	2.132	0.100	0.000	0.062
break - adaptation VE	threshold : 0%	64	16.205	17.285	0.768	0.000	4.867	0.000	-1.358	7.442	0.000	67.000	0.000
	threshold : 9%	56	16.936	12.089	0.830	0.000	2.351	0.019	1.522	10.390	0.000	1.000	0.000
	threshold : 50%	35	13.514	7.027	0.847	0.000	3.047	0.002	1.699	11.214	0.000	0.000	0.000
	threshold : 90%	5	13.193	2.624	0.964	0.838	0.632	0.527	-0.169	10.057	0.001	0.000	0.062
adaptation PE - instruction	Skin Conductance	64	-0.042	0.276	0.940	0.004	2.855	0.004	-1.024	-1.195	0.237	943.000	0.517
	Phasic Component	64	-1.059	2.567	0.399	0.000	5.790	0.000	-4.410	-3.274	0.002	78.000	0.000
	Tonic Component	64	1.048	2.603	0.477	0.000	5.827	0.000	4.311	3.195	0.002	267.000	0.000
adaptation PE - break	Skin Conductance	64	-0.446	0.599	0.882	0.000	2.003	0.045	-1.247	-5.908	0.000	226.000	0.000
	Phasic Component	64	-3.372	6.165	0.530	0.000	4.544	0.000	-2.925	-4.341	0.000	0.000	0.000
	Tonic Component	64	2.530	6.576	0.578	0.000	4.447	0.000	2.827	3.053	0.003	706.000	0.026
adaptation PE - adaptation VE	Skin Conductance	64	-0.253	0.387	0.963	0.054	2.150	0.032	-0.653	-5.185	0.000	338.000	0.000
	Phasic Component	64	-0.116	0.626	0.568	0.000	5.591	0.000	-1.611	-1.470	0.146	640.000	0.007
	Tonic Component	64	-0.547	1.202	0.970	0.117	2.094	0.036	-0.428	-3.615	0.001	538.000	0.001
instruction - break	Skin Conductance	64	-0.404	0.536	0.823	0.000	3.825	0.000	-1.924	-5.984	0.000	140.000	0.000
	Phasic Component	64	-2.313	5.189	0.553	0.000	5.036	0.000	-3.258	-3.538	0.001	200.000	0.000
	Tonic Component	64	1.482	5.602	0.578	0.000	4.943	0.000	3.174	2.100	0.040	1011.000	0.846
instruction - adaptation VE	Skin Conductance	64	-0.211	0.364	0.954	0.018	1.558	0.119	-0.793	-4.603	0.000	417.000	0.000
	Phasic Component	64	0.943	2.492	0.449	0.000	5.636	0.000	4.123	3.004	0.004	195.000	0.000
	Tonic Component	64	-1.595	2.452	0.567	0.000	5.732	0.000	-4.016	-5.163	0.000	80.000	0.000
break - adaptation VE	Skin Conductance	64	0.193	0.513	0.780	0.000	4.439	0.000	2.302	2.982	0.004	697.000	0.022
	Phasic Component	64	3.256	5.977	0.523	0.000	4.381	0.000	2.842	4.325	0.000	0.000	0.000
	Tonic Component	64	-3.077	6.337	0.562	0.000	4.454	0.000	-2.870	-3.854	0.000	253.000	0.000

Functions¶

reading data from .xlsx files¶

Identifying indexes for phases¶

Calculating sample age parameters¶

Testing proportion of missing Heart Rate data in the sample¶

Calculating mean value of parameter¶

Calculating statistics for the experiment¶

Saving results¶

Main function analysing data from the experiment¶

Execution¶

data holder¶